//#define _CRT_SECURE_NO_WARNINGS 1
//#include<iostream>
//#include<vector>
//#include<unordered_map>
//
//using namespace std;
//
//int n = 0, m = 0;
//int t1 = 0, t2 = 0;
//unordered_map<int, vector<pair<int, int>>> mp;
//int min_ans = 0;
//int flags[101] = { 0 };
//
//void dfs(const int& begin, const int& end, int index, int ans, bool f)
//{
//    if (flags[index] != 0 || (f && index == begin))
//    {
//        return;
//    }
//    if (index == end)
//    {
//        min_ans = min(ans, min_ans);
//        return;
//    }
//    vector<pair<int, int>> indexs = mp[index];
//    flags[index] = 1;
//    for (int i = 0; i < indexs.size(); i++)
//    {
//        if ((indexs[i].first == t1 && index == t2) || (indexs[i].first == t2 && index == t1))
//        {
//            dfs(begin, end, indexs[i].first, ans, true);
//        }
//        else
//        {
//            ans += indexs[i].second;
//            dfs(begin, end, indexs[i].first, ans, true);
//            ans -= indexs[i].second;
//        }
//    }
//    flags[index] = 0;
//}
//
//int main()
//{
//    cin >> n >> m;
//    int begin = 0, end = 0;
//    cin >> begin >> end;
//    cin >> t1 >> t2;
//    for (int i = 0; i < m; i++)
//    {
//        int u = 0, v = 0, t = 0;
//        cin >> u >> v >> t;
//        mp[u].push_back({ v,t });
//        mp[v].push_back({ u,t });
//        min_ans += t;
//    }
//    int ans = 0;
//    dfs(begin, end, begin, ans, false);
//    cout << min_ans << endl;
//
//    return 0;
//}

//#include<iostream>
//#include<vector>
//#include<unordered_map>
//#include<algorithm>
//
//using namespace std;
//const int MOD = 998244353;
//const int MAX_LEN = 200000 + 1;
//int main()
//{
//    int n = 0;
//    cin >> n;
//    vector<int> a(n, 0);
//    for (int i = 0; i < n; i++)
//    {
//        cin >> a[i];
//    }
//    // vector<int> ll(n,0),rl(n,0);
//    // vector<long long> lc(n,0),rc(n,0);
//    int ll[MAX_LEN] = { 0 }, rl[MAX_LEN] = { 0 };
//    long long lc[MAX_LEN] = { 0 }, rc[MAX_LEN] = { 0 };
//    vector<int> v;
//    for (int i = 0; i < n; i++)
//    {
//        int temp = a[i];
//        auto it = lower_bound(v.begin(), v.end(), temp);
//        int index = it - v.begin();
//        ll[i] = index + 1;
//        if (index < v.size())
//        {
//            v[index] = temp;
//        }
//        else
//        {
//            v.push_back(temp);
//        }
//
//        if (ll[i] == 1)
//        {
//            lc[i] = 1;
//        }
//        else
//        {
//            long long count = 0;
//            for (int j = 0; j < i; j++)
//            {
//                if (ll[j] == ll[i] - 1 && a[j] < a[i])
//                {
//                    count = (count + lc[j]) % MOD;
//                }
//            }
//            lc[i] = count;
//        }
//    }
//
//    v.clear();
//    for (int i = n - 1; i >= 0; i--)
//    {
//        int temp = a[i];
//        auto it = lower_bound(v.begin(), v.end(), -temp);
//        int index = it - v.begin();
//        rl[i] = index + 1;
//        if (index < v.size())
//        {
//            v[index] = -temp;
//        }
//        else
//        {
//            v.push_back(-temp);
//        }
//
//        if (rl[i] == 1)
//        {
//            rc[i] = 1;
//        }
//        else
//        {
//            long long count = 0;
//            for (int j = i + 1; j < n; j++)
//            {
//                if (rl[j] == rl[i] - 1 && a[j] > a[i])
//                {
//                    count = (count + rc[j]) % MOD;
//                }
//            }
//            rc[i] = count;
//        }
//    }
//
//    for (int i = 0; i < n; i++)
//    {
//        long long ans = (lc[i] * rc[i]) % MOD;
//        cout << ans << endl;
//    }
//    return 0;
//}

#include<iostream>
#include<vector>
#include<unordered_map>

using namespace std;
const int MOD = 998244353;

int main()
{
    int n = 0;
    cin >> n;
    vector<int> a(n, 0);
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    unordered_map<int, vector<vector<int>>> mp;
    int max_len = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 1; j < a[i]; j++)
        {
            if (mp.count(j))
            {
                // mp[j].push_back(a[i]);
                vector<vector<int>> vp = mp[j];
                bool flag = true;
                for (int k = 0; k < vp.size(); k++)
                {
                    vector<int> v = vp[k];
                    if (v.back() < a[i])
                    {
                        mp[j][k].push_back(a[i]);
                        flag = false;
                    }
                    max_len = max(mp[j][k].size(), (size_t)max_len);
                }
                if (flag)
                {
                    vector<int> v = { j,a[i] };
                    mp[j].push_back(v);
                }
            }
        }
        mp[a[i]] = { {a[i]} };
    }
    vector<vector<int>> ans;
    for (const auto& vp : mp)
    {
        for (const auto& v : vp.second)
        {
            if (v.size() == max_len)
            {
                ans.push_back(v);
            }
        }
    }

    unordered_map<int, int> mmp;
    for (auto& v : ans)
    {
        for (auto& e : v)
        {
            mmp[e]++;
            mmp[e] %= MOD;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        cout << mmp[a[i - 1]] << endl;
    }

    return 0;
}